/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package myTest;

import java.awt.FlowLayout;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.swing.JFrame;

/**
 * 
 * @author chenwei767
 */
@SuppressWarnings("unused")
public class MainTest {

	public static void main(String[] args) {
		Question6 testClose = new Question6();
		// Question5.run();
		// Question4.run();
		// Question3.run();
		// Question2.run();
		// Question1.run();
	}
}

@SuppressWarnings("serial")
class Question6 extends JFrame {
	/*  写一个窗口程序，用户单击窗口上的“×”按纽时，能关闭该窗口。 */

	public Question6() {
		setLayout(new FlowLayout());
		setSize(200, 100);
		setVisible(true);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	}
}

class Question5 {
	/*
	 * 编写一个程序，用于实现文件的备份，程序运行时的命令语法为： java MyCopy (sourcefile) (destfile)
	 */

	public static void run() {
		try {
			copyfile("/home/chenwei767/aa", "/home/chenwei767/aa-backup");// backup
																			// aa
																			// to
																			// aa-backup
		} catch (FileNotFoundException ex) {
			Logger.getLogger(Question5.class.getName()).log(Level.SEVERE, null, ex);
		} catch (IOException ex) {
			Logger.getLogger(Question5.class.getName()).log(Level.SEVERE, null, ex);
		}
	}

	public static void copyfile(String srFile, String dtFile) throws FileNotFoundException, IOException {
		File f1 = new File(srFile);
		File f2 = new File(dtFile);
		InputStream in = new FileInputStream(f1);
		OutputStream out = new FileOutputStream(f2);

		byte[] buf = new byte[1024];
		int len;
		while ((len = in.read(buf)) > 0) {
			out.write(buf, 0, len);
		}
		in.close();
		out.close();
		System.out.println("file has been copied.");
	}
}

class Question4 {

	private static final char digits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };

	/*
	 * 请用移位的方式打印出一个十进制整数的十六进制形式。提示：按每4个二进制位对整数进
	 * 行移位和去高位处理，得到的结果就是十六进制数的一位，然后按下面三种方式之一（作为
	 * 作业，要求每种方式都用到）计算出一个十六进制数值对应的十六进制形式：
	 * （1）0-9之间的数值直接加上字符'0'，9以上的数值减去10以后再加上字符'A'
	 * （2）定义一个数组，其中包含0-F这些字符，然后用要计算的数值作为数组的索引号，即可 获得其对应的十六进制数据。
	 * （3）Character.forDigit静态方法可以将一个十六进制的数字转变成其对应的字符表示形 式，例如，根据数值15返回字符'F'。
	 */

	public static void run() {

		int[] param = new int[] { 56224 };
		StringBuilder sb = new StringBuilder();
		q1(param, sb);
		System.out.println("0x" + sb);

		param = new int[] { 56224 };
		q2(param, sb);
		System.out.println("0x" + sb);

		param = new int[] { 56224 };
		q3(param, sb);
		System.out.println("0x" + sb);
	}

	private static void q2(int[] param, StringBuilder sb) {
		sb.setLength(0);
		while (param[0] > 0) {
			char c;
			int tmp = getLowest4bits(param);
			c = digits[tmp];
			sb.insert(0, c);
		}
	}

	private static void q1(int[] param, StringBuilder sb) {
		sb.setLength(0);
		while (param[0] > 0) {
			char c;
			int tmp = getLowest4bits(param);
			if (tmp <= 9) {
				c = (char) (tmp + '0');
			} else {
				tmp -= 10;
				c = (char) (tmp + 'a');
			}
			sb.insert(0, c);
		}
	}

	private static void q3(int[] param, StringBuilder sb) {
		sb.setLength(0);
		while (param[0] > 0) {
			char c = Character.forDigit(getLowest4bits(param), 16);
			sb.insert(0, c);
		}
	}

	private static int getLowest4bits(int[] param) {
		int tmp = param[0] & 15;
		param[0] >>>= 4;
		return tmp;
	}
}

class Question3 {
	/*
	 * 编写一个程序，它先将键盘上输入的一个字符串转换成十进制整数，然后打印出这个十
	 * 进制整数对应的二进制形式。这个程序要考虑输入的字符串不能转换成一个十进制整数
	 * 的情况，并对转换失败的原因要区分出是数字太大，还是其中包含有非数字字符的情况。
	 * 提示：十进制数转二进制数的方式是用这个数除以2，余数就是二进制数的最低位，接着
	 * 再用得到的商作为被除数去除以2，这次得到的余数就是次低位，如此循环，直到被除数为
	 * 0为止。其实，只要明白了打印出一个十进制数的每一位的方式（不断除以10，得到的余数
	 * 就分别是个位，十位，百位），就很容易理解十进制数转二进制数的这种方式。
	 */

	public static void run() {
		String binary = convert("-3235");
		System.out.println(binary);

		binary = convert("23235");
		System.out.println(binary);

		binary = convert("2321412qw34");
		System.out.println(binary);

		binary = convert("23224141341435");
		System.out.println(binary);
	}

	private static String convert(String decimalString) {
		int input;
		boolean flag = true;// positive number
		if (decimalString.charAt(0) == '-') {
			flag = false;// decimal inputed is negtive number
			decimalString = decimalString.substring(1);
		}

		for (int i = 0; i < decimalString.length(); i++) {
			char c = decimalString.charAt(i);
			if (c < '0' || c > '9') {
				System.out.println("inputing contains illegal char");
				return "";
			}
		}

		try {
			input = Integer.valueOf(decimalString);

		} catch (Exception ex) {
			System.out.println("inputing number is too larger to be converted.");
			return "";
		}

		StringBuilder binary = new StringBuilder();

		while (input > 0) {
			int tmp = input % 2;
			input /= 2;
			binary.insert(0, tmp);
		}
		if (!flag) {
			binary.insert(0, '-');
		}
		return binary.toString();
	}
}

class Question2 {
	/*
	 * 请在一个类中编写一个方法，这个方法搜索一个字符数组中是否存在某个字符， 如果存在，则返回这个字符在字符数组中第一次出现的位置（序号从0开始计算），
	 * 否则，返回-1。要搜索的字符数组和字符都以参数形式传递传递给该方法，如果传入 的数组为null，应抛出
	 * IllegalArgumentException异常。在类的main方法中以
	 * 各种可能出现的情况测试验证该方法编写得是否正确，例如，字符不存在，字符存在，传入的数组为null等。
	 */

	public static void run() {
		char[] chars = new char[] { 'd', 'b', 'd', 'a', 'c' };

		int ret = find('b', chars);
		System.out.println(ret);

		ret = find('d', chars);
		System.out.println(ret);

		ret = find('t', chars);
		System.out.println(ret);

		try {
			ret = find('t', null);
			System.out.println(ret);
		} catch (Exception ex) {
			System.out.println("IllegalArguentException has been catched");
		}
	}

	private static int find(char c, char[] chars) {
		if (chars == null) {
			throw new IllegalArgumentException();
		}
		for (int i = 0; i < chars.length; i++) {
			if (chars[i] == c) {
				return i;
			}
		}
		return -1;
	}
}

class Question1 {
	/*
	 * 编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，
	 * 例如，根据内容为[1][2][3]的数组形成内容为"1,2,3"的字符串。
	 */

	public static void run() {

		int[] arrayInt = new int[] { 1, 3, 4, 2, 5, 6, 2 };

		StringBuilder sb = new StringBuilder();
		for (int tmp : arrayInt) {
			sb.append(tmp).append(",");
		}
		if (sb.length() >= 1) {
			sb.deleteCharAt(sb.length() - 1);
		}

		System.out.println(sb);
	}
}
